﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Web;
using BaseDeDatos;
using BaseDeDatos.Exceptions;
using Protocolo.Exception;

namespace Protocolo
{
    public class Control_calendario
    {
        /// <summary>
        /// Realiza la busqueda de los eventos del mes para luego parsearlos en la interfaz
        /// </summary>
        /// <param name="mes">mes al cual se le esta buscando los eventos</param>
        /// <returns>la lista de eventos de ese mes</returns>
        public static IList busca_evento(string mes)
        {
            try
            {
                IList eventos;
                string query =
                    "select distinct e.Fecha from Evento as e where SUBSTRING(CONVERT(varchar(10), e.Fecha, 103), 4, 7) ='" +
                    mes + "' and e.Estatus = 'Confirmado' AND (e.Fecha >= GETDATE())";
                eventos = (IList) BD.Consultar(query);
                return eventos;
            }
            catch (BDException bde)
            {
                throw (new ConsultaException("Error al hacer la consulta", bde));
            }
            catch (ConexionFallidaException cfe)
            {
                throw (new ConsultaException("Error al hacer la consulta", cfe));
            }
        }

        /// <summary>
        /// Funcion que termina de verificar si el guia o entrenante se puede inscribir en el evento
        /// </summary>
        /// <param name="even">Objeto del evento que se va a anotar</param>
        /// <param name="person">Objeto del guia que se quiere anotar</param>
        /// <returns>true si pudo inscribir o false en caso contrario</returns>
        public static bool anotarse_evento(Evento even, Guia person)
        {
            try
            {
                if ((person.Curso == "Si") && (person.Entrevista == "Si"))
                {
                    string query = "select count(*) from Registro where id_evento=" + even.id_evento;

                    int cupos = (int) (((IList) BD.Consultar(query))[0]);
                    if (even.Cant_guias - cupos > 0)
                    {
                        Registro reg = new Registro();
                        reg.Id_evento = even.id_evento;
                        reg.Id_guia = person;
                        reg.Rol = "Guia";
                        reg.Asistencia = "No";
                        BD.SavePerson(reg);
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                else return false;
            }
            catch ( ConexionFallidaException cfe )
            {
                throw (new GuiaAnotadoException("El guia ya esta anotado en este evento", cfe));
            }
            catch ( BDException bde )
            {
                throw (new ErrorException("Ha ocurrido un error", bde));
            }
        }

        /// <summary>
        /// Consulta los eventos en donde no se a confirmado las asistencias de los eventos que ya pasaron
        /// </summary>
        /// <returns>Una lista de eventos</returns>
        public static IList evento_asistencia ()
        {
            string query = "from Evento as e where e.Asistencia='No' and (e.Fecha >= GETDATE())";
            IList events = (IList)BD.Consultar(query);
            return events;
        }

        /// <summary>
        /// Busca los guias o entrenantes que fueron anotados en el evento al que se le va a 
        /// confirmar la asistencia
        /// </summary>
        /// <param name="id">id del evento al que se esta consultando</param>
        /// <returns>Una lista de personas que se anotaron en el evento</returns>
        public static IList Guias_Registro(string id)
        {
            string query = string.Format("select reg.Id_guia from Registro as reg where reg.Id_evento = {0}", id);
            IList guias = (IList) BD.Consultar(query);
            return guias;
        }

        /// <summary>
        /// Busca los eventos para una fecha en especifico
        /// </summary>
        /// <param name="fecha">fecha exacta del dia que se esta buscando</param>
        /// <returns>Una lista con todos los eventos de ese dia</returns>
        public static IList busca_evento_dia(string fecha)
        {
            try
            {
                IList eventos;
                string query = "from Evento where SUBSTRING(CONVERT(varchar(10), fecha_evento, 103), 1,10) ='" + fecha +
                               "' and Estatus = 'Confirmado'";
                eventos = (IList) BD.Consultar(query);
                return eventos;
            }
            catch ( BDException bde )
            {
                throw (new ConsultaException("Error al hacer la consulta",bde));
            }
            catch ( ConexionFallidaException cfe )
            {
                throw (new ConsultaException("Error al hacer la consulta", cfe));
            }
        }

        /// <summary>
        /// Busca un evento en especifico en el cual el guia se puede anotar
        /// </summary>
        /// <param name="id">id del evento al que se quiere consultar</param>
        /// <returns>Un obejto Evento con la informacion del mismo</returns>
        public static Evento busca_unico(string id)
        {
            try
            {
                string query = "from Evento where id_evento=" + id;
                IList aux = (IList) BD.Consultar(query);
                return ((Evento) aux[0]);
            }
            catch (BDException bde)
            {
                throw (new ConsultaException("Error al hacer la consulta", bde));
            }
            catch (ConexionFallidaException cfe)
            {
                throw (new ConsultaException("Error al hacer la consulta", cfe));
            }
        }

        /// <summary>
        /// Metodo que guarda en la BD el Evento.
        /// </summary>
        /// <param name="evento">Evento a guardar</param>
        /// <returns>True si se guardo, false en caso contrario</returns>
        public static Boolean GuardarEvento(Evento evento)
        {
            Boolean guardado;
            try
            {
                BD.SavePerson(evento);
                guardado = true;
            }
            catch (ConexionFallidaException ade)  //Error de conexion (hay que buscar)
            {
                throw (new ConexionFallidaException("Ocurrio un error en la base de datos", ade));
            }
            catch (BDException te)  //cuando no se pudo realizar la transaccion por alguna razon
            {
                throw (new BDException("No se pudo realizar la transaccion", te));
            }
            catch (UsuarioNoInsertadoException ex)
            {
                throw (new UsuarioNoInsertadoException("Ocurrio un error en la Base de Datos", ex));
            }

            return guardado;
        }

        /// <summary>
        /// Metodo que busca la lista de eventos para un determinado mes.
        /// </summary>
        /// <param name="mes">Mes para buscar los eventos</param>
        /// <param name="year">Año del Evento</param>
        /// <returns>Lista de Eventos que cumplan con esa caracteristica.</returns>
        public static IList EventosMes(String mes, string year)
        {
            IList data;

            try
            {
                String query;
                if (mes.Equals("00"))
                {
                    query = " from Evento where estatus='Confirmado' and confirmacion_finanzas='No' " +
                    " and (fecha_evento between " + "convert(datetime,'01/01/" + year +
                    "',103) and convert(datetime,'31/12/" + year + "',103) )";

                }
                else
                {
                    query = " from Evento where estatus='Confirmado' and confirmacion_finanzas='No'" +
                    "and (fecha_evento between " + "convert(datetime,'01/" + mes + "/" + year +
                    "',103) and convert(datetime,'31/" + mes + "/" + year + "',103) )";
                }

                data = (IList)BD.Consultar(query);
            }
            catch (BDException ae)  //alguno de los argumentos es incorrectos
            {
                throw (new BDException("Los argumentos en la consulta son incorrectos", ae));
            }
            catch (ConexionFallidaException ade)  //Error de conexion (hay que buscar)
            {
                throw (new ConexionFallidaException("Ocurrio un error en la base de datos", ade));
            }
            catch (System.Exception ex)
            {
                throw (new BDException("Ocurrio algun error en la base de datos"));
            }


            return data;
        }

        /// <summary>
        /// Metodo que actualiza si fue enviado a Finanzas el pago del evento.
        /// </summary>
        /// <param name="ids">Conjuntos de Id de los eventos a actualizar</param>
        /// <returns>Lista de Id de eventos actualizados</returns>
        public static String[] ActualizarStatusFinanzas(String[] ids)
        {
            int m = 0;
            String[] actualizados = new string[ids.Length];
            try
            {

                for (int r = 0; r < ids.Length; r++)
                {
                    // Status = Si significa que ya se envio el reporte a finanzas.
                    String query = " from Evento where id_evento='" + ids[r] + "'";
                    IList data = (IList)BD.Consultar(query);
                    Evento ev = (Evento)data[0];
                    ev.Conf_finanzas = "Si";

                    BD.Update(ev);
                    actualizados[m] = ev.id_evento.ToString();

                }
            }
            catch (ConexionFallidaException ade)  //Error de conexion (hay que buscar)
            {
                throw (new ConexionFallidaException("Ocurrio un error en la base de datos", ade));
            }
            catch (BDException te)  //cuando no se pudo realizar la transaccion por alguna razon
            {
                throw (new BDException("No se pudo realizar la transaccion", te));
            }
            catch (UsuarioNoInsertadoException ex)
            {
                throw (new UsuarioNoInsertadoException("Ocurrio un error en la Base de Datos", ex));
            }
            return actualizados;
        }

        /// <summary>
        /// Metodo que busca una lista de eventos a partir de la confirmacion de pago.
        /// </summary>
        /// <param name="mes">Mes para consultar</param>
        /// <param name="year">Año para consultar</param>
        /// <param name="tipo">Estatus de la confirmacion de pago</param>
        /// <returns>Lista de eventos que cumplan esas condiciones</returns>
        public static IList ConfirmacionPago(String mes, String year, String tipo)
        {
            IList data;
            try
            {
                String query = "";
                if (tipo.Equals("Todos"))
                {
                    if (mes.Equals("00"))
                    {
                        query = " from Evento where estatus='Confirmado' " +
                        " and (fecha_evento between " + "convert(datetime,'01/01/" + year +
                        "',103) and convert(datetime,'31/12/" + year + "',103) ) order by fecha_evento";

                    }
                    else
                    {
                        query = " from Evento where estatus='Confirmado' " +
                        "and (fecha_evento between " + "convert(datetime,'01/" + mes + "/" + year +
                        "',103) and convert(datetime,'31/" + mes + "/" + year + "',103) ) order by fecha_evento";
                    }

                }
                else if (tipo.Equals("Si"))
                {

                    if (mes.Equals("00"))
                    {
                        query = " from Evento where estatus='Confirmado' and confirmacion_pago='Si' " +
                        " and (fecha_evento between " + "convert(datetime,'01/01/" + year +
                        "',103) and convert(datetime,'31/12/" + year + "',103) ) order by fecha_evento";

                    }
                    else
                    {
                        query = " from Evento where estatus='Confirmado' and confirmacion_pago='Si'" +
                        "and (fecha_evento between " + "convert(datetime,'01/" + mes + "/" + year +
                        "',103) and convert(datetime,'31/" + mes + "/" + year + "',103) ) order by fecha_evento";
                    }
                }
                else if (tipo.Equals("No"))
                {

                    if (mes.Equals("00"))
                    {
                        query = " from Evento where estatus='Confirmado' and confirmacion_pago='No' " +
                        " and (fecha_evento between " + "convert(datetime,'01/01/" + year +
                        "',103) and convert(datetime,'31/12/" + year + "',103) ) order by fecha_evento";

                    }
                    else
                    {
                        query = " from Evento where estatus='Confirmado' and confirmacion_pago='No'" +
                        "and (fecha_evento between " + "convert(datetime,'01/" + mes + "/" + year +
                        "',103) and convert(datetime,'31/" + mes + "/" + year + "',103) ) order by fecha_evento";
                    }
                }

                data = (IList)BD.Consultar(query);
            }
            catch (BDException ae)  //alguno de los argumentos es incorrectos
            {
                throw (new BDException("Los argumentos en la consulta son incorrectos", ae));
            }
            catch (ConexionFallidaException ade)  //Error de conexion (hay que buscar)
            {
                throw (new ConexionFallidaException("Ocurrio un error en la base de datos", ade));
            }
            catch (System.Exception ex)
            {
                throw (new BDException("Ocurrio algun error en la base de datos"));
            }

            return data;

        }

        /// <summary>
        /// Metodo que devuelve los eventos realizados por un organizador.
        /// </summary>
        /// <param name="mes">Mes del Evento</param>
        /// <param name="year">Año del Evento</param>
        /// <param name="id">Identificador del organizador</param>
        /// <returns>Lista de Eventos de ese Organizador</returns>
        public static IList EventosOrganizador(String mes, String year, int id)
        {
            String query;
            IList data;
            try
            {
                if (mes.Equals("00"))
                {
                    query = " from Evento where estatus='Confirmado' and id_organizador=" + id + " " +
                    " and (fecha_evento between " + "convert(datetime,'01/01/" + year +
                    "',103) and convert(datetime,'31/12/" + year + "',103) ) order by fecha_evento";

                }
                else
                {
                    query = " from Evento where estatus='Confirmado' and id_organizador=" + id + " " +
                    "and (fecha_evento between " + "convert(datetime,'01/" + mes + "/" + year +
                    "',103) and convert(datetime,'31/" + mes + "/" + year + "',103) ) order by fecha_evento";
                }

                data = (IList)BD.Consultar(query);
            }
            catch (BDException ae)  //alguno de los argumentos es incorrectos
            {
                throw (new BDException("Los argumentos en la consulta son incorrectos", ae));
            }
            catch (ConexionFallidaException ade)  //Error de conexion (hay que buscar)
            {
                throw (new ConexionFallidaException("Ocurrio un error en la base de datos", ade));
            }
            catch (System.Exception ex)
            {
                throw (new BDException("Ocurrio algun error en la base de datos"));
            }


            return data;
        }
    }
}
